package com.he.hsdyc.controller;

import com.he.hsdyc.ManagementserverApplication;
import com.he.hsdyc.common.log.annotation.TaoLogAnnotation;
import com.he.hsdyc.model.msg.ErrorCode;
import com.he.hsdyc.model.msg.Message;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.test.context.junit4.SpringRunner;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

import javax.servlet.http.HttpServletRequest;
import java.util.*;

@RestController
@RequestMapping("/aop")
//@RunWith(SpringRunner.class)
//@SpringBootTest(classes = ManagementserverApplication.class)
public class AopController {

    private static final Logger LOG = LoggerFactory.getLogger(AopController.class);

    @GetMapping(value = "/index1")//-----------------------匹配切入点表达式，aop生效
    public String index(HttpServletRequest request) {
        LOG.info("这里是业务方法");
        return "匹配切入点表达式，aop生效";
    }

    @GetMapping(value = "/test1")
    public String test1(HttpServletRequest request, String var1) {
        return "test1";
    }

    @TaoLogAnnotation
    @GetMapping(value = "/test2")//------------------------匹配切入点表达式，@TaoLogAnnotation生效
    public String test2(HttpServletRequest request, String var1, String var2) {
        LOG.info("这里是业务方法");
        return "匹配切入点表达式，@TaoLogAnnotation生效";
    }


    /**
     * 功能描述: ArrayList循环删除元素
     * @auther: WT
     * @date: 2019/8/12
     */
    @Test
    public void testList() {

        //新建数组并填充
        List<Integer> list = new ArrayList<>();
        list.add(1);
        list.add(2);
        list.add(4);
        list.add(5);
        list.add(6);
        list.add(8);
        //[1,2,4,5,6,8]


        //1>普通for循环删除元素
        //当删除元素的时候，数组大小会发生变化，其下标会跟着变化，造成元素漏删
        //本例中，第一个元素进行遍历的时候，不满足条件，此时数组大小为6，当前下标指向位置0(值为1),数组为[1,2,4,5,6,8]
        //接下来遍历第二个元素2，满足条件，删除元素，此时数组大小为5，当前下标指向位置1(值为4),数组为[1,4,5,6,8]
        //之后遍历第三个元素5，不满足条件，此时数组大小为5，当前下标指向位置2(值为5),数组为[1,4,5,6,8]
        //接下来遍历第四个元素6，满足条件，删除元素，此时数组大小为4，当前下标指向位置3(值为8),数组为[1,4,5,8]
        //此时数组没有下一元素，结束循环，结果为[1,4,5,8]
        //总结：普通for循环删除list数组元素，满足条件的相邻元素会出现漏删情况
        for(int i=0;i<list.size();i++) {
            if(list.get(i)%2 == 0) {
                list.remove(i);
            }
        }
        //实际输出结果：[1, 4, 5, 8]
        //预测输出结果：[1,5]
        System.out.println(list);


        //2>增强for循环删除元素
        for(Integer i:list) {
            if(list.get(i) %2 == 0) {
                list.remove(i);
                break;
            }
        }
        //会抛异常java.util.ConcurrentModificationException
        System.out.println(list);


        //3>iterater遍历
        Iterator<Integer> iterator = list.iterator();
        while (iterator.hasNext()) {
            if(iterator.next() %2 == 0) {
                //注意不要用list.remove()方法，否则会抛异常
                iterator.remove();
            }
        }
        //实际输出结果：[1,5]
        //预测输出结果：[1,5]
        System.out.println(list);//---------------------------------------------推荐

    }

    /**
     * 功能描述: 五种方式遍历HashMap
     * @auther: WT
     * @date: 2019/8/12
     */
    @Test
    public void testMap() {

        //新建Map并填充
        Map<String, String> map = new HashMap<String, String>();
        map.put("1", "value1");
        map.put("2", "value2");
        map.put("3", "value3");

        //1>lamda直接遍历-----简单，内部实现还是entrySet(推荐)
        map.forEach((k,v) -> System.out.println("key:"+k+"   "+"value:"+v));

        //2>entrySet结合iterator-----优秀(推荐)
        Iterator<Map.Entry<String, String>> iterator = map.entrySet().iterator();
        while (iterator.hasNext()) {
            Map.Entry<String, String> entry = iterator.next();
            System.out.println("key:"+entry.getKey()+"   "+"value:"+entry.getValue());
//            //必须要用itetator.next()获得迭代器，之后才能获取map中的数据，下面这种直接遍历取值会报错
//            System.out.println("key:"+iterator.next().getKey()+"   "+"value:"+iterator.next().getValue());
        }

        //3>entrySet遍历-----简单，算比较常用(推荐)
        for(Map.Entry<String,String> entry:map.entrySet()) {
            System.out.println("key:"+entry.getKey()+"   "+"value:"+entry.getValue());
        }

        //4>keySet遍历-----简单，但是二次取值(不推荐)
        for(String key:map.keySet()) {
            System.out.println("key:"+key+"   "+"value:"+map.get(key));
        }

        //5>values遍历-----只能遍历value(不推荐)
        for(String value:map.values()) {
            System.out.println("value:"+value);
        }



    }
}